package day2;

import java.util.Arrays;

/**
 * javaproject.
 * Create by Devin on 2021/6/11.
 * <p>
 * Copyright (c) 2021-present, Devin.
 * All rights reserved.
 */
public class Main {
    public static void main(String[] args) {
        // 都占用2字节
        char c1 = 'A';
        char c2 = '中';
        // 获取Unicode编码
        int n = c1;

        // 字符串连接
        String s1 = "Hello";
        String s2 = "World";
        String s = s1 + " " + s2;

        // 使用`+`连接其他数据类型会优先将其转换为字符串
        int age = 25;
        String sa = "age is " + age;

        // 字符串不可变(内容不可变，实际变的是指向)
        // 执行`String s1 = "Hello";`时，JVM虚拟机创建字符串`Hello`，然后将变量s1指向它
        // 执行`s1 = "World";`时，VM虚拟机先创建字符串`World`，然后将变量s1指向它
        // 原来的字符串`Hello`还在，并没有改变，只是无法通过变量s1访问
        // 因此字符串的不可变是指字符串内容不可变。
        s1 = "World";

        exp7();
    }

    public static void exp1() {
        String s = "hello";
        String t = s;
        s = "world";
        System.out.println(t); // t是"hello"还是"world"?
    }

    // 将下面一组int值视为字符的Unicode码，把它们拼成一个字符串
    public static void exp2() {
        int a = 72;
        int b = 105;
        int c = 65281;

        char na = (char) a;
        char nb = (char) b;
        char nc = (char) c;

        // 是先转换成字符串，再把char类型加到字符串中的
        String s = "" + na + nb + nc;
        // 先做 char类型的加法，然后再转字符串
        // String s = na + nb + nc + "";
        System.out.println(s);
    }

    // 数组是引用类型，并且数组大小不可变
    // 执行`ns = new int[] {1, 2};`时，指向了一个2个元素的数组
    // 执行`ns = new int[] {1, 2, 3};`时，指向了一个3个元素的数组
    // 原来的数组并没有改变
    public static void exp3() {
        int[] ns; // 定义数组
        ns = new int[] { 1, 2 };
        ns = new int[] { 1, 2, 3 };
    }

    // 类似于字符串修改
    public static void exp4() {
        String[] names = { "ABC", "XYZ", "zoo" };
        String s = names[1];
        names[1] = "cat";
        System.out.println(s);
    }

    public static void exp5() {
        int[] ns = { 1, 2, 3, 4, 5 };
        for (int i = 0; i < ns.length; i++) {
            System.out.println(ns[i]);
        }

        // forEach 无法拿到索引
        // 类似于for in
        for (int n : ns) {
            System.out.println(n);
        }

        System.out.println(Arrays.toString(ns));
    }

    public static void exp6() {
        int[] ns = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };

        // 冒泡排序
        for (int i = 0; i < ns.length - 1; i++) {
            for (int j = 0; j < ns.length - 1 - i; j++) {
                if (ns[j] > ns[j + 1]) {
                    int tmp = ns[j];
                    ns[j] = ns[j + 1];
                    ns[j + 1] = tmp;
                }
            }
        }

        // 排序前
        System.out.println(Arrays.toString(ns));
        // 对数组排序实际上修改了数组本身
        // 如果对一个字符串数组进行排序
        // 字符串在内存中均没有任何变化,但是数组的每个元素指向变化了
        Arrays.sort(ns);
        // 排序后
        System.out.println(Arrays.toString(ns));
    }

    // 降序排序
    public static void exp7() {
        int[] ns = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
        System.out.println(Arrays.toString(ns));

        Arrays.sort(ns);
        int len = ns.length;
        int[] nws = new int[len];
        for (int i = 0; i < len; i++) {
            nws[i] = ns[len - i - 1];
        }
        ns = nws;
        System.out.println(Arrays.toString(ns));

        // 2.利用冒泡排序
        for (int i = 0; i < ns.length - 1; i++) {
            for (int j = 0; j < ns.length - i - 1; j++) {
                if (ns[j] < ns[j+1]) {
                    int tmp = ns[j];
                    ns[j] = ns[j+1];
                    ns[j+1] = tmp;
                }
            }
        }
        System.out.println(Arrays.toString(ns));
    }
}
